// $ANTLR 3.3 Nov 30, 2010 12:45:30 D:\\project\\Amuthu\\Amuthu.g 2011-03-21 17:10:44

package org.amuthu.parser;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

public class AmuthuLexer extends Lexer {
    public static final int EOF=-1;
    public static final int T__31=31;
    public static final int UNARY_MINUS=4;
    public static final int LPAREN=5;
    public static final int RPAREN=6;
    public static final int QUESTION=7;
    public static final int OR=8;
    public static final int AND=9;
    public static final int EQUALS=10;
    public static final int NOT_EQUALS=11;
    public static final int LESSTHAN_EQ=12;
    public static final int GREATERTHAN_EQ=13;
    public static final int LESSTHAN=14;
    public static final int GREATERTHAN=15;
    public static final int PLUS=16;
    public static final int MINUS=17;
    public static final int MULTIPLY=18;
    public static final int DIVIDE=19;
    public static final int MODULO=20;
    public static final int POWER=21;
    public static final int NOT=22;
    public static final int INTEGER=23;
    public static final int DOUBLE=24;
    public static final int BOOLEAN=25;
    public static final int QUOTE=26;
    public static final int IDENTIFIER=27;
    public static final int COMMA=28;
    public static final int ASSIGN=29;
    public static final int WHITESPACE=30;

    // delegates
    // delegators

    public AmuthuLexer() {;} 
    public AmuthuLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public AmuthuLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);

    }
    public String getGrammarFileName() { return "D:\\project\\Amuthu\\Amuthu.g"; }

    // $ANTLR start "T__31"
    public final void mT__31() throws RecognitionException {
        try {
            int _type = T__31;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:7:7: ( ':' )
            // D:\\project\\Amuthu\\Amuthu.g:7:9: ':'
            {
            match(':'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "T__31"

    // $ANTLR start "LPAREN"
    public final void mLPAREN() throws RecognitionException {
        try {
            int _type = LPAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:101:2: ( '(' )
            // D:\\project\\Amuthu\\Amuthu.g:101:5: '('
            {
            match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LPAREN"

    // $ANTLR start "RPAREN"
    public final void mRPAREN() throws RecognitionException {
        try {
            int _type = RPAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:103:2: ( ')' )
            // D:\\project\\Amuthu\\Amuthu.g:103:5: ')'
            {
            match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RPAREN"

    // $ANTLR start "QUESTION"
    public final void mQUESTION() throws RecognitionException {
        try {
            int _type = QUESTION;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:105:2: ( '?' )
            // D:\\project\\Amuthu\\Amuthu.g:105:5: '?'
            {
            match('?'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "QUESTION"

    // $ANTLR start "COMMA"
    public final void mCOMMA() throws RecognitionException {
        try {
            int _type = COMMA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:107:2: ( ',' )
            // D:\\project\\Amuthu\\Amuthu.g:107:4: ','
            {
            match(','); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COMMA"

    // $ANTLR start "ASSIGN"
    public final void mASSIGN() throws RecognitionException {
        try {
            int _type = ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:108:9: ( '=' )
            // D:\\project\\Amuthu\\Amuthu.g:108:11: '='
            {
            match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ASSIGN"

    // $ANTLR start "OR"
    public final void mOR() throws RecognitionException {
        try {
            int _type = OR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:109:7: ( 'or' )
            // D:\\project\\Amuthu\\Amuthu.g:109:10: 'or'
            {
            match("or"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OR"

    // $ANTLR start "AND"
    public final void mAND() throws RecognitionException {
        try {
            int _type = AND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:110:8: ( 'and' )
            // D:\\project\\Amuthu\\Amuthu.g:110:11: 'and'
            {
            match("and"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AND"

    // $ANTLR start "EQUALS"
    public final void mEQUALS() throws RecognitionException {
        try {
            int _type = EQUALS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:111:9: ( '==' )
            // D:\\project\\Amuthu\\Amuthu.g:111:11: '=='
            {
            match("=="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "EQUALS"

    // $ANTLR start "NOT_EQUALS"
    public final void mNOT_EQUALS() throws RecognitionException {
        try {
            int _type = NOT_EQUALS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:112:12: ( '!=' )
            // D:\\project\\Amuthu\\Amuthu.g:112:14: '!='
            {
            match("!="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NOT_EQUALS"

    // $ANTLR start "LESSTHAN"
    public final void mLESSTHAN() throws RecognitionException {
        try {
            int _type = LESSTHAN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:113:11: ( '<' )
            // D:\\project\\Amuthu\\Amuthu.g:113:13: '<'
            {
            match('<'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LESSTHAN"

    // $ANTLR start "LESSTHAN_EQ"
    public final void mLESSTHAN_EQ() throws RecognitionException {
        try {
            int _type = LESSTHAN_EQ;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:114:13: ( '<=' )
            // D:\\project\\Amuthu\\Amuthu.g:114:15: '<='
            {
            match("<="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LESSTHAN_EQ"

    // $ANTLR start "GREATERTHAN"
    public final void mGREATERTHAN() throws RecognitionException {
        try {
            int _type = GREATERTHAN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:115:13: ( '>' )
            // D:\\project\\Amuthu\\Amuthu.g:115:15: '>'
            {
            match('>'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GREATERTHAN"

    // $ANTLR start "GREATERTHAN_EQ"
    public final void mGREATERTHAN_EQ() throws RecognitionException {
        try {
            int _type = GREATERTHAN_EQ;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:116:16: ( '>=' )
            // D:\\project\\Amuthu\\Amuthu.g:116:18: '>='
            {
            match(">="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GREATERTHAN_EQ"

    // $ANTLR start "PLUS"
    public final void mPLUS() throws RecognitionException {
        try {
            int _type = PLUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:117:8: ( '+' )
            // D:\\project\\Amuthu\\Amuthu.g:117:10: '+'
            {
            match('+'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "PLUS"

    // $ANTLR start "MINUS"
    public final void mMINUS() throws RecognitionException {
        try {
            int _type = MINUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:118:9: ( '-' )
            // D:\\project\\Amuthu\\Amuthu.g:118:11: '-'
            {
            match('-'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MINUS"

    // $ANTLR start "MULTIPLY"
    public final void mMULTIPLY() throws RecognitionException {
        try {
            int _type = MULTIPLY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:119:12: ( '*' )
            // D:\\project\\Amuthu\\Amuthu.g:119:14: '*'
            {
            match('*'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MULTIPLY"

    // $ANTLR start "DIVIDE"
    public final void mDIVIDE() throws RecognitionException {
        try {
            int _type = DIVIDE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:120:10: ( '/' )
            // D:\\project\\Amuthu\\Amuthu.g:120:12: '/'
            {
            match('/'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DIVIDE"

    // $ANTLR start "MODULO"
    public final void mMODULO() throws RecognitionException {
        try {
            int _type = MODULO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:121:10: ( '%' )
            // D:\\project\\Amuthu\\Amuthu.g:121:12: '%'
            {
            match('%'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MODULO"

    // $ANTLR start "POWER"
    public final void mPOWER() throws RecognitionException {
        try {
            int _type = POWER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:122:9: ( '^' )
            // D:\\project\\Amuthu\\Amuthu.g:122:11: '^'
            {
            match('^'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "POWER"

    // $ANTLR start "NOT"
    public final void mNOT() throws RecognitionException {
        try {
            int _type = NOT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:123:5: ( '!' | 'not' )
            int alt1=2;
            int LA1_0 = input.LA(1);

            if ( (LA1_0=='!') ) {
                alt1=1;
            }
            else if ( (LA1_0=='n') ) {
                alt1=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                throw nvae;
            }
            switch (alt1) {
                case 1 :
                    // D:\\project\\Amuthu\\Amuthu.g:123:7: '!'
                    {
                    match('!'); 

                    }
                    break;
                case 2 :
                    // D:\\project\\Amuthu\\Amuthu.g:123:13: 'not'
                    {
                    match("not"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NOT"

    // $ANTLR start "BOOLEAN"
    public final void mBOOLEAN() throws RecognitionException {
        try {
            int _type = BOOLEAN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:124:10: ( 'true' | 'false' )
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0=='t') ) {
                alt2=1;
            }
            else if ( (LA2_0=='f') ) {
                alt2=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // D:\\project\\Amuthu\\Amuthu.g:124:12: 'true'
                    {
                    match("true"); 


                    }
                    break;
                case 2 :
                    // D:\\project\\Amuthu\\Amuthu.g:124:21: 'false'
                    {
                    match("false"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BOOLEAN"

    // $ANTLR start "QUOTE"
    public final void mQUOTE() throws RecognitionException {
        try {
            int _type = QUOTE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:126:2: ( 'open' | 'high' | 'low' | 'close' | 'volume' )
            int alt3=5;
            switch ( input.LA(1) ) {
            case 'o':
                {
                alt3=1;
                }
                break;
            case 'h':
                {
                alt3=2;
                }
                break;
            case 'l':
                {
                alt3=3;
                }
                break;
            case 'c':
                {
                alt3=4;
                }
                break;
            case 'v':
                {
                alt3=5;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }

            switch (alt3) {
                case 1 :
                    // D:\\project\\Amuthu\\Amuthu.g:126:4: 'open'
                    {
                    match("open"); 


                    }
                    break;
                case 2 :
                    // D:\\project\\Amuthu\\Amuthu.g:126:13: 'high'
                    {
                    match("high"); 


                    }
                    break;
                case 3 :
                    // D:\\project\\Amuthu\\Amuthu.g:126:22: 'low'
                    {
                    match("low"); 


                    }
                    break;
                case 4 :
                    // D:\\project\\Amuthu\\Amuthu.g:126:30: 'close'
                    {
                    match("close"); 


                    }
                    break;
                case 5 :
                    // D:\\project\\Amuthu\\Amuthu.g:126:40: 'volume'
                    {
                    match("volume"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "QUOTE"

    // $ANTLR start "INTEGER"
    public final void mINTEGER() throws RecognitionException {
        try {
            int _type = INTEGER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:128:9: ( ( '0' | '1' .. '9' ( '0' .. '9' )* ) )
            // D:\\project\\Amuthu\\Amuthu.g:128:11: ( '0' | '1' .. '9' ( '0' .. '9' )* )
            {
            // D:\\project\\Amuthu\\Amuthu.g:128:11: ( '0' | '1' .. '9' ( '0' .. '9' )* )
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0=='0') ) {
                alt5=1;
            }
            else if ( ((LA5_0>='1' && LA5_0<='9')) ) {
                alt5=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;
            }
            switch (alt5) {
                case 1 :
                    // D:\\project\\Amuthu\\Amuthu.g:128:12: '0'
                    {
                    match('0'); 

                    }
                    break;
                case 2 :
                    // D:\\project\\Amuthu\\Amuthu.g:128:18: '1' .. '9' ( '0' .. '9' )*
                    {
                    matchRange('1','9'); 
                    // D:\\project\\Amuthu\\Amuthu.g:128:27: ( '0' .. '9' )*
                    loop4:
                    do {
                        int alt4=2;
                        int LA4_0 = input.LA(1);

                        if ( ((LA4_0>='0' && LA4_0<='9')) ) {
                            alt4=1;
                        }


                        switch (alt4) {
                    	case 1 :
                    	    // D:\\project\\Amuthu\\Amuthu.g:128:27: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    break loop4;
                        }
                    } while (true);


                    }
                    break;

            }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "INTEGER"

    // $ANTLR start "DOUBLE"
    public final void mDOUBLE() throws RecognitionException {
        try {
            int _type = DOUBLE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:129:8: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* | '.' ( '0' .. '9' )+ )
            int alt9=2;
            int LA9_0 = input.LA(1);

            if ( ((LA9_0>='0' && LA9_0<='9')) ) {
                alt9=1;
            }
            else if ( (LA9_0=='.') ) {
                alt9=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;
            }
            switch (alt9) {
                case 1 :
                    // D:\\project\\Amuthu\\Amuthu.g:129:10: ( '0' .. '9' )+ '.' ( '0' .. '9' )*
                    {
                    // D:\\project\\Amuthu\\Amuthu.g:129:10: ( '0' .. '9' )+
                    int cnt6=0;
                    loop6:
                    do {
                        int alt6=2;
                        int LA6_0 = input.LA(1);

                        if ( ((LA6_0>='0' && LA6_0<='9')) ) {
                            alt6=1;
                        }


                        switch (alt6) {
                    	case 1 :
                    	    // D:\\project\\Amuthu\\Amuthu.g:129:11: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt6 >= 1 ) break loop6;
                                EarlyExitException eee =
                                    new EarlyExitException(6, input);
                                throw eee;
                        }
                        cnt6++;
                    } while (true);

                    match('.'); 
                    // D:\\project\\Amuthu\\Amuthu.g:129:26: ( '0' .. '9' )*
                    loop7:
                    do {
                        int alt7=2;
                        int LA7_0 = input.LA(1);

                        if ( ((LA7_0>='0' && LA7_0<='9')) ) {
                            alt7=1;
                        }


                        switch (alt7) {
                    	case 1 :
                    	    // D:\\project\\Amuthu\\Amuthu.g:129:27: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    break loop7;
                        }
                    } while (true);


                    }
                    break;
                case 2 :
                    // D:\\project\\Amuthu\\Amuthu.g:129:40: '.' ( '0' .. '9' )+
                    {
                    match('.'); 
                    // D:\\project\\Amuthu\\Amuthu.g:129:44: ( '0' .. '9' )+
                    int cnt8=0;
                    loop8:
                    do {
                        int alt8=2;
                        int LA8_0 = input.LA(1);

                        if ( ((LA8_0>='0' && LA8_0<='9')) ) {
                            alt8=1;
                        }


                        switch (alt8) {
                    	case 1 :
                    	    // D:\\project\\Amuthu\\Amuthu.g:129:45: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt8 >= 1 ) break loop8;
                                EarlyExitException eee =
                                    new EarlyExitException(8, input);
                                throw eee;
                        }
                        cnt8++;
                    } while (true);


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "DOUBLE"

    // $ANTLR start "IDENTIFIER"
    public final void mIDENTIFIER() throws RecognitionException {
        try {
            int _type = IDENTIFIER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:130:12: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )
            // D:\\project\\Amuthu\\Amuthu.g:130:14: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            {
            if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}

            // D:\\project\\Amuthu\\Amuthu.g:130:38: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            loop10:
            do {
                int alt10=2;
                int LA10_0 = input.LA(1);

                if ( ((LA10_0>='0' && LA10_0<='9')||(LA10_0>='A' && LA10_0<='Z')||LA10_0=='_'||(LA10_0>='a' && LA10_0<='z')) ) {
                    alt10=1;
                }


                switch (alt10) {
            	case 1 :
            	    // D:\\project\\Amuthu\\Amuthu.g:
            	    {
            	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop10;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "IDENTIFIER"

    // $ANTLR start "WHITESPACE"
    public final void mWHITESPACE() throws RecognitionException {
        try {
            int _type = WHITESPACE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\project\\Amuthu\\Amuthu.g:131:12: ( ( ' ' | '\\t' | '\\r' | '\\n' ) )
            // D:\\project\\Amuthu\\Amuthu.g:131:14: ( ' ' | '\\t' | '\\r' | '\\n' )
            {
            if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}

             _channel = HIDDEN; 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WHITESPACE"

    public void mTokens() throws RecognitionException {
        // D:\\project\\Amuthu\\Amuthu.g:1:8: ( T__31 | LPAREN | RPAREN | QUESTION | COMMA | ASSIGN | OR | AND | EQUALS | NOT_EQUALS | LESSTHAN | LESSTHAN_EQ | GREATERTHAN | GREATERTHAN_EQ | PLUS | MINUS | MULTIPLY | DIVIDE | MODULO | POWER | NOT | BOOLEAN | QUOTE | INTEGER | DOUBLE | IDENTIFIER | WHITESPACE )
        int alt11=27;
        alt11 = dfa11.predict(input);
        switch (alt11) {
            case 1 :
                // D:\\project\\Amuthu\\Amuthu.g:1:10: T__31
                {
                mT__31(); 

                }
                break;
            case 2 :
                // D:\\project\\Amuthu\\Amuthu.g:1:16: LPAREN
                {
                mLPAREN(); 

                }
                break;
            case 3 :
                // D:\\project\\Amuthu\\Amuthu.g:1:23: RPAREN
                {
                mRPAREN(); 

                }
                break;
            case 4 :
                // D:\\project\\Amuthu\\Amuthu.g:1:30: QUESTION
                {
                mQUESTION(); 

                }
                break;
            case 5 :
                // D:\\project\\Amuthu\\Amuthu.g:1:39: COMMA
                {
                mCOMMA(); 

                }
                break;
            case 6 :
                // D:\\project\\Amuthu\\Amuthu.g:1:45: ASSIGN
                {
                mASSIGN(); 

                }
                break;
            case 7 :
                // D:\\project\\Amuthu\\Amuthu.g:1:52: OR
                {
                mOR(); 

                }
                break;
            case 8 :
                // D:\\project\\Amuthu\\Amuthu.g:1:55: AND
                {
                mAND(); 

                }
                break;
            case 9 :
                // D:\\project\\Amuthu\\Amuthu.g:1:59: EQUALS
                {
                mEQUALS(); 

                }
                break;
            case 10 :
                // D:\\project\\Amuthu\\Amuthu.g:1:66: NOT_EQUALS
                {
                mNOT_EQUALS(); 

                }
                break;
            case 11 :
                // D:\\project\\Amuthu\\Amuthu.g:1:77: LESSTHAN
                {
                mLESSTHAN(); 

                }
                break;
            case 12 :
                // D:\\project\\Amuthu\\Amuthu.g:1:86: LESSTHAN_EQ
                {
                mLESSTHAN_EQ(); 

                }
                break;
            case 13 :
                // D:\\project\\Amuthu\\Amuthu.g:1:98: GREATERTHAN
                {
                mGREATERTHAN(); 

                }
                break;
            case 14 :
                // D:\\project\\Amuthu\\Amuthu.g:1:110: GREATERTHAN_EQ
                {
                mGREATERTHAN_EQ(); 

                }
                break;
            case 15 :
                // D:\\project\\Amuthu\\Amuthu.g:1:125: PLUS
                {
                mPLUS(); 

                }
                break;
            case 16 :
                // D:\\project\\Amuthu\\Amuthu.g:1:130: MINUS
                {
                mMINUS(); 

                }
                break;
            case 17 :
                // D:\\project\\Amuthu\\Amuthu.g:1:136: MULTIPLY
                {
                mMULTIPLY(); 

                }
                break;
            case 18 :
                // D:\\project\\Amuthu\\Amuthu.g:1:145: DIVIDE
                {
                mDIVIDE(); 

                }
                break;
            case 19 :
                // D:\\project\\Amuthu\\Amuthu.g:1:152: MODULO
                {
                mMODULO(); 

                }
                break;
            case 20 :
                // D:\\project\\Amuthu\\Amuthu.g:1:159: POWER
                {
                mPOWER(); 

                }
                break;
            case 21 :
                // D:\\project\\Amuthu\\Amuthu.g:1:165: NOT
                {
                mNOT(); 

                }
                break;
            case 22 :
                // D:\\project\\Amuthu\\Amuthu.g:1:169: BOOLEAN
                {
                mBOOLEAN(); 

                }
                break;
            case 23 :
                // D:\\project\\Amuthu\\Amuthu.g:1:177: QUOTE
                {
                mQUOTE(); 

                }
                break;
            case 24 :
                // D:\\project\\Amuthu\\Amuthu.g:1:183: INTEGER
                {
                mINTEGER(); 

                }
                break;
            case 25 :
                // D:\\project\\Amuthu\\Amuthu.g:1:191: DOUBLE
                {
                mDOUBLE(); 

                }
                break;
            case 26 :
                // D:\\project\\Amuthu\\Amuthu.g:1:198: IDENTIFIER
                {
                mIDENTIFIER(); 

                }
                break;
            case 27 :
                // D:\\project\\Amuthu\\Amuthu.g:1:209: WHITESPACE
                {
                mWHITESPACE(); 

                }
                break;

        }

    }


    protected DFA11 dfa11 = new DFA11(this);
    static final String DFA11_eotS =
        "\6\uffff\1\37\2\34\1\44\1\46\1\50\6\uffff\7\34\2\60\5\uffff\1\62"+
        "\2\34\6\uffff\7\34\1\uffff\1\60\1\uffff\1\34\1\75\1\44\3\34\1\101"+
        "\2\34\1\101\1\uffff\1\104\1\34\1\101\1\uffff\2\34\1\uffff\1\104"+
        "\1\101\1\34\1\101";
    static final String DFA11_eofS =
        "\111\uffff";
    static final String DFA11_minS =
        "\1\11\5\uffff\1\75\1\160\1\156\3\75\6\uffff\1\157\1\162\1\141\1"+
        "\151\1\157\1\154\1\157\2\56\5\uffff\1\60\1\145\1\144\6\uffff\1\164"+
        "\1\165\1\154\1\147\1\167\1\157\1\154\1\uffff\1\56\1\uffff\1\156"+
        "\2\60\1\145\1\163\1\150\1\60\1\163\1\165\1\60\1\uffff\1\60\1\145"+
        "\1\60\1\uffff\1\145\1\155\1\uffff\2\60\1\145\1\60";
    static final String DFA11_maxS =
        "\1\172\5\uffff\1\75\1\162\1\156\3\75\6\uffff\1\157\1\162\1\141"+
        "\1\151\1\157\1\154\1\157\2\71\5\uffff\1\172\1\145\1\144\6\uffff"+
        "\1\164\1\165\1\154\1\147\1\167\1\157\1\154\1\uffff\1\71\1\uffff"+
        "\1\156\2\172\1\145\1\163\1\150\1\172\1\163\1\165\1\172\1\uffff\1"+
        "\172\1\145\1\172\1\uffff\1\145\1\155\1\uffff\2\172\1\145\1\172";
    static final String DFA11_acceptS =
        "\1\uffff\1\1\1\2\1\3\1\4\1\5\6\uffff\1\17\1\20\1\21\1\22\1\23\1"+
        "\24\11\uffff\1\31\1\32\1\33\1\11\1\6\3\uffff\1\12\1\25\1\14\1\13"+
        "\1\16\1\15\7\uffff\1\30\1\uffff\1\7\12\uffff\1\10\3\uffff\1\27\2"+
        "\uffff\1\26\4\uffff";
    static final String DFA11_specialS =
        "\111\uffff}>";
    static final String[] DFA11_transitionS = {
            "\2\35\2\uffff\1\35\22\uffff\1\35\1\11\3\uffff\1\20\2\uffff"+
            "\1\2\1\3\1\16\1\14\1\5\1\15\1\33\1\17\1\31\11\32\1\1\1\uffff"+
            "\1\12\1\6\1\13\1\4\1\uffff\32\34\3\uffff\1\21\1\34\1\uffff\1"+
            "\10\1\34\1\27\2\34\1\24\1\34\1\25\3\34\1\26\1\34\1\22\1\7\4"+
            "\34\1\23\1\34\1\30\4\34",
            "",
            "",
            "",
            "",
            "",
            "\1\36",
            "\1\41\1\uffff\1\40",
            "\1\42",
            "\1\43",
            "\1\45",
            "\1\47",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\51",
            "\1\52",
            "\1\53",
            "\1\54",
            "\1\55",
            "\1\56",
            "\1\57",
            "\1\33\1\uffff\12\33",
            "\1\33\1\uffff\12\61",
            "",
            "",
            "",
            "",
            "",
            "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
            "\1\63",
            "\1\64",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\65",
            "\1\66",
            "\1\67",
            "\1\70",
            "\1\71",
            "\1\72",
            "\1\73",
            "",
            "\1\33\1\uffff\12\61",
            "",
            "\1\74",
            "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
            "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
            "\1\76",
            "\1\77",
            "\1\100",
            "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
            "\1\102",
            "\1\103",
            "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
            "",
            "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
            "\1\105",
            "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
            "",
            "\1\106",
            "\1\107",
            "",
            "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
            "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
            "\1\110",
            "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34"
    };

    static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS);
    static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS);
    static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS);
    static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS);
    static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS);
    static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS);
    static final short[][] DFA11_transition;

    static {
        int numStates = DFA11_transitionS.length;
        DFA11_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA11_transition[i] = DFA.unpackEncodedString(DFA11_transitionS[i]);
        }
    }

    class DFA11 extends DFA {

        public DFA11(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 11;
            this.eot = DFA11_eot;
            this.eof = DFA11_eof;
            this.min = DFA11_min;
            this.max = DFA11_max;
            this.accept = DFA11_accept;
            this.special = DFA11_special;
            this.transition = DFA11_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( T__31 | LPAREN | RPAREN | QUESTION | COMMA | ASSIGN | OR | AND | EQUALS | NOT_EQUALS | LESSTHAN | LESSTHAN_EQ | GREATERTHAN | GREATERTHAN_EQ | PLUS | MINUS | MULTIPLY | DIVIDE | MODULO | POWER | NOT | BOOLEAN | QUOTE | INTEGER | DOUBLE | IDENTIFIER | WHITESPACE );";
        }
    }
 

}